home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex1 < prev    next >
Encoding:
Text File  |  1988-05-19  |  38.2 KB  |  2,012 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. zshowbox ( p ) 
  5. halfword p ; 
  6. {showbox_regmem 
  7.   depththreshold = eqtb [ 5292 ] .cint ; 
  8.   breadthmax = eqtb [ 5291 ] .cint ; 
  9.   if ( breadthmax <= 0 ) 
  10.   breadthmax = 5 ; 
  11.   if ( poolptr + depththreshold >= poolsize ) 
  12.   depththreshold = poolsize - poolptr - 1 ; 
  13.   shownodelist ( p ) ; 
  14.   println () ; 
  15. } 
  16. zdeletetokenref ( p ) 
  17. halfword p ; 
  18. {deletetokenref_regmem 
  19.   if ( mem [ p ] .hh .v.LH == 0 ) 
  20.   flushlist ( p ) ; 
  21.   else decr ( mem [ p ] .hh .v.LH ) ; 
  22. } 
  23. zdeleteglueref ( p ) 
  24. halfword p ; 
  25. {deleteglueref_regmem 
  26.   if ( mem [ p ] .hh .v.RH == 0 ) 
  27.   freenode ( p , 4 ) ; 
  28.   else decr ( mem [ p ] .hh .v.RH ) ; 
  29. } 
  30. zflushnodelist ( p ) 
  31. halfword p ; 
  32. {/* 30 */ flushnodelist_regmem 
  33.   halfword q  ; 
  34.   while ( p != 0 ) {
  35.       
  36.     q = mem [ p ] .hh .v.RH ; 
  37.     if ( ( p >= himemmin ) ) 
  38.     {
  39.       mem [ p ] .hh .v.RH = avail ; 
  40.       avail = p ; 
  41.     ;
  42. #ifdef STAT
  43.       decr ( dynused ) ; 
  44. #endif /* STAT */
  45.     } 
  46.     else {
  47.     
  48.       switch ( mem [ p ] .hh.b0 ) 
  49.       {case 0 : 
  50.       case 1 : 
  51.       case 13 : 
  52.     {
  53.       flushnodelist ( mem [ p + 5 ] .hh .v.RH ) ; 
  54.       freenode ( p , 7 ) ; 
  55.       goto lab30 ; 
  56.     } 
  57.     break ; 
  58.       case 2 : 
  59.     {
  60.       freenode ( p , 4 ) ; 
  61.       goto lab30 ; 
  62.     } 
  63.     break ; 
  64.       case 3 : 
  65.     {
  66.       flushnodelist ( mem [ p + 4 ] .hh .v.LH ) ; 
  67.       deleteglueref ( mem [ p + 4 ] .hh .v.RH ) ; 
  68.       freenode ( p , 5 ) ; 
  69.       goto lab30 ; 
  70.     } 
  71.     break ; 
  72.       case 8 : 
  73.     {
  74.       switch ( mem [ p ] .hh.b1 ) 
  75.       {case 0 : 
  76.         freenode ( p , 3 ) ; 
  77.         break ; 
  78.       case 1 : 
  79.       case 3 : 
  80.         {
  81.           deletetokenref ( mem [ p + 1 ] .hh .v.RH ) ; 
  82.           freenode ( p , 2 ) ; 
  83.           goto lab30 ; 
  84.         } 
  85.         break ; 
  86.       case 2 : 
  87.         freenode ( p , 2 ) ; 
  88.         break ; 
  89.         default: 
  90.         confusion ( 1137 ) ; 
  91.         break ; 
  92.       } 
  93.       goto lab30 ; 
  94.     } 
  95.     break ; 
  96.       case 10 : 
  97.     {
  98.       {
  99.         if ( mem [ mem [ p + 1 ] .hh .v.LH ] .hh .v.RH == 0 ) 
  100.         freenode ( mem [ p + 1 ] .hh .v.LH , 4 ) ; 
  101.         else decr ( mem [ mem [ p + 1 ] .hh .v.LH ] .hh .v.RH ) ; 
  102.       } 
  103.       if ( mem [ p + 1 ] .hh .v.RH != 0 ) 
  104.       flushnodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  105.     } 
  106.     break ; 
  107.       case 11 : 
  108.       case 9 : 
  109.       case 12 : 
  110.     ; 
  111.     break ; 
  112.       case 6 : 
  113.     flushnodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  114.     break ; 
  115.       case 4 : 
  116.     deletetokenref ( mem [ p + 1 ] .cint ) ; 
  117.     break ; 
  118.       case 7 : 
  119.     {
  120.       flushnodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  121.       flushnodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  122.     } 
  123.     break ; 
  124.       case 5 : 
  125.     flushnodelist ( mem [ p + 1 ] .cint ) ; 
  126.     break ; 
  127.       case 14 : 
  128.     {
  129.       freenode ( p , 3 ) ; 
  130.       goto lab30 ; 
  131.     } 
  132.     break ; 
  133.       case 15 : 
  134.     {
  135.       flushnodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  136.       flushnodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  137.       flushnodelist ( mem [ p + 2 ] .hh .v.LH ) ; 
  138.       flushnodelist ( mem [ p + 2 ] .hh .v.RH ) ; 
  139.       freenode ( p , 3 ) ; 
  140.       goto lab30 ; 
  141.     } 
  142.     break ; 
  143.       case 16 : 
  144.       case 17 : 
  145.       case 18 : 
  146.       case 19 : 
  147.       case 20 : 
  148.       case 21 : 
  149.       case 22 : 
  150.       case 23 : 
  151.       case 24 : 
  152.       case 27 : 
  153.       case 26 : 
  154.       case 29 : 
  155.       case 28 : 
  156.     {
  157.       if ( mem [ p + 1 ] .hh .v.RH >= 2 ) 
  158.       flushnodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  159.       if ( mem [ p + 2 ] .hh .v.RH >= 2 ) 
  160.       flushnodelist ( mem [ p + 2 ] .hh .v.LH ) ; 
  161.       if ( mem [ p + 3 ] .hh .v.RH >= 2 ) 
  162.       flushnodelist ( mem [ p + 3 ] .hh .v.LH ) ; 
  163.       if ( mem [ p ] .hh.b0 == 24 ) 
  164.       freenode ( p , 5 ) ; 
  165.       else if ( mem [ p ] .hh.b0 == 28 ) 
  166.       freenode ( p , 5 ) ; 
  167.       else freenode ( p , 4 ) ; 
  168.       goto lab30 ; 
  169.     } 
  170.     break ; 
  171.       case 30 : 
  172.       case 31 : 
  173.     {
  174.       freenode ( p , 4 ) ; 
  175.       goto lab30 ; 
  176.     } 
  177.     break ; 
  178.       case 25 : 
  179.     {
  180.       flushnodelist ( mem [ p + 2 ] .hh .v.LH ) ; 
  181.       flushnodelist ( mem [ p + 3 ] .hh .v.LH ) ; 
  182.       freenode ( p , 6 ) ; 
  183.       goto lab30 ; 
  184.     } 
  185.     break ; 
  186.     default: 
  187.     confusion ( 221 ) ; 
  188.     break ; 
  189.       } 
  190.       freenode ( p , 2 ) ; 
  191.       lab30: ; 
  192.     } 
  193.     p = q ; 
  194.   } 
  195. } 
  196. halfword zcopynodelist ( p ) 
  197. halfword p ; 
  198. {register halfword Result; copynodelist_regmem 
  199.   halfword h  ; 
  200.   halfword q  ; 
  201.   halfword r  ; 
  202.   schar words  ; 
  203.   h = getavail () ; 
  204.   q = h ; 
  205.   while ( p != 0 ) {
  206.       
  207.     words = 1 ; 
  208.     if ( ( p >= himemmin ) ) 
  209.     r = getavail () ; 
  210.     else switch ( mem [ p ] .hh.b0 ) 
  211.     {case 0 : 
  212.     case 1 : 
  213.     case 13 : 
  214.       {
  215.     r = getnode ( 7 ) ; 
  216.     mem [ r + 6 ] = mem [ p + 6 ] ; 
  217.     mem [ r + 5 ] = mem [ p + 5 ] ; 
  218.     mem [ r + 5 ] .hh .v.RH = copynodelist ( mem [ p + 5 ] .hh .v.RH ) ; 
  219.     words = 5 ; 
  220.       } 
  221.       break ; 
  222.     case 2 : 
  223.       {
  224.     r = getnode ( 4 ) ; 
  225.     words = 4 ; 
  226.       } 
  227.       break ; 
  228.     case 3 : 
  229.       {
  230.     r = getnode ( 5 ) ; 
  231.     mem [ r + 4 ] = mem [ p + 4 ] ; 
  232.     incr ( mem [ mem [ p + 4 ] .hh .v.RH ] .hh .v.RH ) ; 
  233.     mem [ r + 4 ] .hh .v.LH = copynodelist ( mem [ p + 4 ] .hh .v.LH ) ; 
  234.     words = 4 ; 
  235.       } 
  236.       break ; 
  237.     case 8 : 
  238.       switch ( mem [ p ] .hh.b1 ) 
  239.       {case 0 : 
  240.     {
  241.       r = getnode ( 3 ) ; 
  242.       words = 3 ; 
  243.     } 
  244.     break ; 
  245.       case 1 : 
  246.       case 3 : 
  247.     {
  248.       r = getnode ( 2 ) ; 
  249.       incr ( mem [ mem [ p + 1 ] .hh .v.RH ] .hh .v.LH ) ; 
  250.       words = 2 ; 
  251.     } 
  252.     break ; 
  253.       case 2 : 
  254.     {
  255.       r = getnode ( 2 ) ; 
  256.       words = 2 ; 
  257.     } 
  258.     break ; 
  259.     default: 
  260.     confusion ( 1136 ) ; 
  261.     break ; 
  262.       } 
  263.       break ; 
  264.     case 10 : 
  265.       {
  266.     r = getnode ( 2 ) ; 
  267.     incr ( mem [ mem [ p + 1 ] .hh .v.LH ] .hh .v.RH ) ; 
  268.     mem [ r + 1 ] .hh .v.LH = mem [ p + 1 ] .hh .v.LH ; 
  269.     mem [ r + 1 ] .hh .v.RH = copynodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  270.       } 
  271.       break ; 
  272.     case 11 : 
  273.     case 9 : 
  274.     case 12 : 
  275.       {
  276.     r = getnode ( 2 ) ; 
  277.     words = 2 ; 
  278.       } 
  279.       break ; 
  280.     case 6 : 
  281.       {
  282.     r = getnode ( 2 ) ; 
  283.     mem [ r + 1 ] = mem [ p + 1 ] ; 
  284.     mem [ r + 1 ] .hh .v.RH = copynodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  285.       } 
  286.       break ; 
  287.     case 7 : 
  288.       {
  289.     r = getnode ( 2 ) ; 
  290.     mem [ r + 1 ] .hh .v.LH = copynodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  291.     mem [ r + 1 ] .hh .v.RH = copynodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  292.       } 
  293.       break ; 
  294.     case 4 : 
  295.       {
  296.     r = getnode ( 2 ) ; 
  297.     incr ( mem [ mem [ p + 1 ] .cint ] .hh .v.LH ) ; 
  298.     words = 2 ; 
  299.       } 
  300.       break ; 
  301.     case 5 : 
  302.       {
  303.     r = getnode ( 2 ) ; 
  304.     mem [ r + 1 ] .cint = copynodelist ( mem [ p + 1 ] .cint ) ; 
  305.       } 
  306.       break ; 
  307.       default: 
  308.       confusion ( 222 ) ; 
  309.       break ; 
  310.     } 
  311.     while ( words > 0 ) {
  312.     
  313.       decr ( words ) ; 
  314.       mem [ r + words ] = mem [ p + words ] ; 
  315.     } 
  316.     mem [ q ] .hh .v.RH = r ; 
  317.     q = r ; 
  318.     p = mem [ p ] .hh .v.RH ; 
  319.   } 
  320.   mem [ q ] .hh .v.RH = 0 ; 
  321.   q = mem [ h ] .hh .v.RH ; 
  322.   {
  323.     mem [ h ] .hh .v.RH = avail ; 
  324.     avail = h ; 
  325.     ;
  326. #ifdef STAT
  327.     decr ( dynused ) ; 
  328. #endif /* STAT */
  329.   } 
  330.   Result = q ; 
  331.   return(Result) ; 
  332. } 
  333. zprintmode ( m ) 
  334. integer m ; 
  335. {printmode_regmem 
  336.   if ( m > 0 ) 
  337.   switch ( m / ( 100 ) ) 
  338.   {case 0 : 
  339.     print ( 223 ) ; 
  340.     break ; 
  341.   case 1 : 
  342.     print ( 224 ) ; 
  343.     break ; 
  344.   case 2 : 
  345.     print ( 225 ) ; 
  346.     break ; 
  347.   } 
  348.   else if ( m == 0 ) 
  349.   print ( 226 ) ; 
  350.   else switch ( ( - (integer) m ) / ( 100 ) ) 
  351.   {case 0 : 
  352.     print ( 227 ) ; 
  353.     break ; 
  354.   case 1 : 
  355.     print ( 228 ) ; 
  356.     break ; 
  357.   case 2 : 
  358.     print ( 211 ) ; 
  359.     break ; 
  360.   } 
  361.   print ( 229 ) ; 
  362. } 
  363. pushnest () {
  364.     pushnest_regmem 
  365.   if ( nestptr > maxneststack ) 
  366.   {
  367.     maxneststack = nestptr ; 
  368.     if ( nestptr == nestsize ) 
  369.     overflow ( 230 , nestsize ) ; 
  370.   } 
  371.   nest [ nestptr ] = curlist ; 
  372.   incr ( nestptr ) ; 
  373.   curlist .headfield = getavail () ; 
  374.   curlist .tailfield = curlist .headfield ; 
  375.   curlist .pgfield = 0 ; 
  376.   curlist .mlfield = line ; 
  377. } 
  378. popnest () {
  379.     popnest_regmem 
  380.   {
  381.     mem [ curlist .headfield ] .hh .v.RH = avail ; 
  382.     avail = curlist .headfield ; 
  383.     ;
  384. #ifdef STAT
  385.     decr ( dynused ) ; 
  386. #endif /* STAT */
  387.   } 
  388.   decr ( nestptr ) ; 
  389.   curlist = nest [ nestptr ] ; 
  390. } 
  391. showactivities () {
  392.     showactivities_regmem 
  393.   integer p  ; 
  394.   short m  ; 
  395.   integer a  ; 
  396.   halfword q, r  ; 
  397.   integer t  ; 
  398.   nest [ nestptr ] = curlist ; 
  399.   printnl ( 206 ) ; 
  400.   println () ; 
  401.   {register integer for_end; p = nestptr ; for_end = 0 ; if ( p >= for_end) 
  402.   do 
  403.     {
  404.       m = nest [ p ] .modefield ; 
  405.       a = nest [ p ] .auxfield ; 
  406.       printnl ( 231 ) ; 
  407.       printmode ( m ) ; 
  408.       print ( 232 ) ; 
  409.       printint ( abs ( nest [ p ] .mlfield ) ) ; 
  410.       if ( nest [ p ] .mlfield < 0 ) 
  411.       print ( 233 ) ; 
  412.       if ( p == 0 ) 
  413.       {
  414.     if ( memtop - 2 != pagetail ) 
  415.     {
  416.       printnl ( 828 ) ; 
  417.       if ( outputactive ) 
  418.       print ( 829 ) ; 
  419.       showbox ( mem [ memtop - 2 ] .hh .v.RH ) ; 
  420.       if ( pagecontents > 0 ) 
  421.       {
  422.         printnl ( 830 ) ; 
  423.         printtotals () ; 
  424.         printnl ( 831 ) ; 
  425.         printscaled ( pagesofar [ 0 ] ) ; 
  426.         r = mem [ memtop ] .hh .v.RH ; 
  427.         while ( r != memtop ) {
  428.         
  429.           println () ; 
  430.           printesc ( 198 ) ; 
  431.           t = mem [ r ] .hh.b1 ; 
  432.           printint ( t ) ; 
  433.           print ( 832 ) ; 
  434.           t = xovern ( mem [ r + 3 ] .cint , 1000 ) * eqtb [ 5317 + t ] 
  435.           .cint ; 
  436.           printscaled ( t ) ; 
  437.           if ( mem [ r ] .hh.b0 == 1 ) 
  438.           {
  439.         q = memtop - 2 ; 
  440.         t = 0 ; 
  441.         do {
  442.             q = mem [ q ] .hh .v.RH ; 
  443.           if ( ( mem [ q ] .hh.b0 == 3 ) && ( mem [ q ] .hh.b1 == mem 
  444.           [ r ] .hh.b1 ) ) 
  445.           incr ( t ) ; 
  446.         } while ( ! ( q == mem [ r + 1 ] .hh .v.LH ) ) ; 
  447.         print ( 833 ) ; 
  448.         printint ( t ) ; 
  449.         print ( 834 ) ; 
  450.           } 
  451.           r = mem [ r ] .hh .v.RH ; 
  452.         } 
  453.       } 
  454.     } 
  455.     if ( mem [ memtop - 1 ] .hh .v.RH != 0 ) 
  456.     printnl ( 234 ) ; 
  457.       } 
  458.       showbox ( mem [ nest [ p ] .headfield ] .hh .v.RH ) ; 
  459.       switch ( abs ( m ) / ( 100 ) ) 
  460.       {case 0 : 
  461.     {
  462.       printnl ( 235 ) ; 
  463.       if ( a <= -65536000L ) 
  464.       print ( 236 ) ; 
  465.       else printscaled ( a ) ; 
  466.       if ( nest [ p ] .pgfield != 0 ) 
  467.       {
  468.         print ( 237 ) ; 
  469.         printint ( nest [ p ] .pgfield ) ; 
  470.         print ( 238 ) ; 
  471.         if ( nest [ p ] .pgfield != 1 ) 
  472.         printchar ( 115 ) ; 
  473.       } 
  474.     } 
  475.     break ; 
  476.       case 1 : 
  477.     {
  478.       printnl ( 239 ) ; 
  479.       printint ( a ) ; 
  480.     } 
  481.     break ; 
  482.       case 2 : 
  483.     if ( a != 0 ) 
  484.     {
  485.       print ( 240 ) ; 
  486.       showbox ( a ) ; 
  487.     } 
  488.     break ; 
  489.       } 
  490.     } 
  491.   while ( p-- > for_end ) ; } 
  492. } 
  493. zprintparam ( n ) 
  494. integer n ; 
  495. {printparam_regmem 
  496.   switch ( n ) 
  497.   {case 0 : 
  498.     printesc ( 285 ) ; 
  499.     break ; 
  500.   case 1 : 
  501.     printesc ( 286 ) ; 
  502.     break ; 
  503.   case 2 : 
  504.     printesc ( 287 ) ; 
  505.     break ; 
  506.   case 3 : 
  507.     printesc ( 288 ) ; 
  508.     break ; 
  509.   case 4 : 
  510.     printesc ( 289 ) ; 
  511.     break ; 
  512.   case 5 : 
  513.     printesc ( 290 ) ; 
  514.     break ; 
  515.   case 6 : 
  516.     printesc ( 291 ) ; 
  517.     break ; 
  518.   case 7 : 
  519.     printesc ( 292 ) ; 
  520.     break ; 
  521.   case 8 : 
  522.     printesc ( 293 ) ; 
  523.     break ; 
  524.   case 9 : 
  525.     printesc ( 294 ) ; 
  526.     break ; 
  527.   case 10 : 
  528.     printesc ( 295 ) ; 
  529.     break ; 
  530.   case 11 : 
  531.     printesc ( 296 ) ; 
  532.     break ; 
  533.   case 12 : 
  534.     printesc ( 297 ) ; 
  535.     break ; 
  536.   case 13 : 
  537.     printesc ( 298 ) ; 
  538.     break ; 
  539.   case 14 : 
  540.     printesc ( 299 ) ; 
  541.     break ; 
  542.   case 15 : 
  543.     printesc ( 300 ) ; 
  544.     break ; 
  545.   case 16 : 
  546.     printesc ( 301 ) ; 
  547.     break ; 
  548.   case 17 : 
  549.     printesc ( 302 ) ; 
  550.     break ; 
  551.   case 18 : 
  552.     printesc ( 303 ) ; 
  553.     break ; 
  554.   case 19 : 
  555.     printesc ( 304 ) ; 
  556.     break ; 
  557.   case 20 : 
  558.     printesc ( 305 ) ; 
  559.     break ; 
  560.   case 21 : 
  561.     printesc ( 306 ) ; 
  562.     break ; 
  563.   case 22 : 
  564.     printesc ( 307 ) ; 
  565.     break ; 
  566.   case 23 : 
  567.     printesc ( 308 ) ; 
  568.     break ; 
  569.   case 24 : 
  570.     printesc ( 309 ) ; 
  571.     break ; 
  572.   case 25 : 
  573.     printesc ( 310 ) ; 
  574.     break ; 
  575.   case 26 : 
  576.     printesc ( 311 ) ; 
  577.     break ; 
  578.   case 27 : 
  579.     printesc ( 312 ) ; 
  580.     break ; 
  581.   case 28 : 
  582.     printesc ( 313 ) ; 
  583.     break ; 
  584.   case 29 : 
  585.     printesc ( 314 ) ; 
  586.     break ; 
  587.   case 30 : 
  588.     printesc ( 315 ) ; 
  589.     break ; 
  590.   case 31 : 
  591.     printesc ( 316 ) ; 
  592.     break ; 
  593.   case 32 : 
  594.     printesc ( 317 ) ; 
  595.     break ; 
  596.   case 33 : 
  597.     printesc ( 318 ) ; 
  598.     break ; 
  599.   case 34 : 
  600.     printesc ( 319 ) ; 
  601.     break ; 
  602.   case 35 : 
  603.     printesc ( 320 ) ; 
  604.     break ; 
  605.   case 36 : 
  606.     printesc ( 321 ) ; 
  607.     break ; 
  608.   case 37 : 
  609.     printesc ( 322 ) ; 
  610.     break ; 
  611.   case 38 : 
  612.     printesc ( 323 ) ; 
  613.     break ; 
  614.   case 39 : 
  615.     printesc ( 324 ) ; 
  616.     break ; 
  617.   case 40 : 
  618.     printesc ( 325 ) ; 
  619.     break ; 
  620.   case 41 : 
  621.     printesc ( 326 ) ; 
  622.     break ; 
  623.   case 42 : 
  624.     printesc ( 327 ) ; 
  625.     break ; 
  626.   case 43 : 
  627.     printesc ( 328 ) ; 
  628.     break ; 
  629.   case 44 : 
  630.     printesc ( 329 ) ; 
  631.     break ; 
  632.   case 45 : 
  633.     printesc ( 330 ) ; 
  634.     break ; 
  635.   case 46 : 
  636.     printesc ( 331 ) ; 
  637.     break ; 
  638.   case 47 : 
  639.     printesc ( 332 ) ; 
  640.     break ; 
  641.   case 48 : 
  642.     printesc ( 333 ) ; 
  643.     break ; 
  644.   case 49 : 
  645.     printesc ( 334 ) ; 
  646.     break ; 
  647.     default: 
  648.     print ( 335 ) ; 
  649.     break ; 
  650.   } 
  651. } 
  652. begindiagnostic () {
  653.     begindiagnostic_regmem 
  654.   oldsetting = selector ; 
  655.   if ( ( eqtb [ 5296 ] .cint <= 0 ) && ( selector == 19 ) ) 
  656.   {
  657.     decr ( selector ) ; 
  658.     if ( history == 0 ) 
  659.     history = 1 ; 
  660.   } 
  661. } 
  662. zenddiagnostic ( blankline ) 
  663. boolean blankline ; 
  664. {enddiagnostic_regmem 
  665.   printnl ( 206 ) ; 
  666.   if ( blankline ) 
  667.   println () ; 
  668.   selector = oldsetting ; 
  669. } 
  670. zprintlengthparam ( n ) 
  671. integer n ; 
  672. {printlengthparam_regmem 
  673.   switch ( n ) 
  674.   {case 0 : 
  675.     printesc ( 338 ) ; 
  676.     break ; 
  677.   case 1 : 
  678.     printesc ( 339 ) ; 
  679.     break ; 
  680.   case 2 : 
  681.     printesc ( 340 ) ; 
  682.     break ; 
  683.   case 3 : 
  684.     printesc ( 341 ) ; 
  685.     break ; 
  686.   case 4 : 
  687.     printesc ( 342 ) ; 
  688.     break ; 
  689.   case 5 : 
  690.     printesc ( 343 ) ; 
  691.     break ; 
  692.   case 6 : 
  693.     printesc ( 344 ) ; 
  694.     break ; 
  695.   case 7 : 
  696.     printesc ( 345 ) ; 
  697.     break ; 
  698.   case 8 : 
  699.     printesc ( 346 ) ; 
  700.     break ; 
  701.   case 9 : 
  702.     printesc ( 347 ) ; 
  703.     break ; 
  704.   case 10 : 
  705.     printesc ( 348 ) ; 
  706.     break ; 
  707.   case 11 : 
  708.     printesc ( 349 ) ; 
  709.     break ; 
  710.   case 12 : 
  711.     printesc ( 350 ) ; 
  712.     break ; 
  713.   case 13 : 
  714.     printesc ( 351 ) ; 
  715.     break ; 
  716.   case 14 : 
  717.     printesc ( 352 ) ; 
  718.     break ; 
  719.   case 15 : 
  720.     printesc ( 353 ) ; 
  721.     break ; 
  722.   case 16 : 
  723.     printesc ( 354 ) ; 
  724.     break ; 
  725.   case 17 : 
  726.     printesc ( 355 ) ; 
  727.     break ; 
  728.   case 18 : 
  729.     printesc ( 356 ) ; 
  730.     break ; 
  731.   case 19 : 
  732.     printesc ( 357 ) ; 
  733.     break ; 
  734.     default: 
  735.     print ( 358 ) ; 
  736.     break ; 
  737.   } 
  738. } 
  739. zprintcmdchr ( cmd , chrcode ) 
  740. quarterword cmd ; 
  741. halfword chrcode ; 
  742. {printcmdchr_regmem 
  743.   switch ( cmd ) 
  744.   {case 1 : 
  745.     {
  746.       print ( 415 ) ; 
  747.       printASCII ( chrcode ) ; 
  748.     } 
  749.     break ; 
  750.   case 2 : 
  751.     {
  752.       print ( 416 ) ; 
  753.       printASCII ( chrcode ) ; 
  754.     } 
  755.     break ; 
  756.   case 3 : 
  757.     {
  758.       print ( 417 ) ; 
  759.       printASCII ( chrcode ) ; 
  760.     } 
  761.     break ; 
  762.   case 6 : 
  763.     {
  764.       print ( 418 ) ; 
  765.       printASCII ( chrcode ) ; 
  766.     } 
  767.     break ; 
  768.   case 7 : 
  769.     {
  770.       print ( 419 ) ; 
  771.       printASCII ( chrcode ) ; 
  772.     } 
  773.     break ; 
  774.   case 8 : 
  775.     {
  776.       print ( 420 ) ; 
  777.       printASCII ( chrcode ) ; 
  778.     } 
  779.     break ; 
  780.   case 9 : 
  781.     print ( 421 ) ; 
  782.     break ; 
  783.   case 10 : 
  784.     {
  785.       print ( 422 ) ; 
  786.       printASCII ( chrcode ) ; 
  787.     } 
  788.     break ; 
  789.   case 11 : 
  790.     {
  791.       print ( 423 ) ; 
  792.       printASCII ( chrcode ) ; 
  793.     } 
  794.     break ; 
  795.   case 12 : 
  796.     {
  797.       print ( 424 ) ; 
  798.       printASCII ( chrcode ) ; 
  799.     } 
  800.     break ; 
  801.   case 74 : 
  802.   case 75 : 
  803.     if ( chrcode < 3544 ) 
  804.     printskipparam ( chrcode - 3526 ) ; 
  805.     else if ( chrcode < 3800 ) 
  806.     {
  807.       printesc ( 260 ) ; 
  808.       printint ( chrcode - 3544 ) ; 
  809.     } 
  810.     else {
  811.     
  812.       printesc ( 261 ) ; 
  813.       printint ( chrcode - 3800 ) ; 
  814.     } 
  815.     break ; 
  816.   case 71 : 
  817.     if ( chrcode >= 4066 ) 
  818.     {
  819.       printesc ( 272 ) ; 
  820.       printint ( chrcode - 4066 ) ; 
  821.     } 
  822.     else switch ( chrcode ) 
  823.     {case 4057 : 
  824.       printesc ( 263 ) ; 
  825.       break ; 
  826.     case 4058 : 
  827.       printesc ( 264 ) ; 
  828.       break ; 
  829.     case 4059 : 
  830.       printesc ( 265 ) ; 
  831.       break ; 
  832.     case 4060 : 
  833.       printesc ( 266 ) ; 
  834.       break ; 
  835.     case 4061 : 
  836.       printesc ( 267 ) ; 
  837.       break ; 
  838.     case 4062 : 
  839.       printesc ( 268 ) ; 
  840.       break ; 
  841.     case 4063 : 
  842.       printesc ( 269 ) ; 
  843.       break ; 
  844.     case 4064 : 
  845.       printesc ( 270 ) ; 
  846.       break ; 
  847.       default: 
  848.       printesc ( 271 ) ; 
  849.       break ; 
  850.     } 
  851.     break ; 
  852.   case 72 : 
  853.     if ( chrcode < 5317 ) 
  854.     printparam ( chrcode - 5267 ) ; 
  855.     else {
  856.     
  857.       printesc ( 336 ) ; 
  858.       printint ( chrcode - 5317 ) ; 
  859.     } 
  860.     break ; 
  861.   case 73 : 
  862.     if ( chrcode < 5721 ) 
  863.     printlengthparam ( chrcode - 5701 ) ; 
  864.     else {
  865.     
  866.       printesc ( 359 ) ; 
  867.       printint ( chrcode - 5721 ) ; 
  868.     } 
  869.     break ; 
  870.   case 45 : 
  871.     printesc ( 367 ) ; 
  872.     break ; 
  873.   case 89 : 
  874.     printesc ( 368 ) ; 
  875.     break ; 
  876.   case 40 : 
  877.     printesc ( 369 ) ; 
  878.     break ; 
  879.   case 41 : 
  880.     printesc ( 370 ) ; 
  881.     break ; 
  882.   case 76 : 
  883.     printesc ( 378 ) ; 
  884.     break ; 
  885.   case 61 : 
  886.     printesc ( 371 ) ; 
  887.     break ; 
  888.   case 42 : 
  889.     printesc ( 389 ) ; 
  890.     break ; 
  891.   case 16 : 
  892.     printesc ( 372 ) ; 
  893.     break ; 
  894.   case 106 : 
  895.     printesc ( 363 ) ; 
  896.     break ; 
  897.   case 87 : 
  898.     printesc ( 377 ) ; 
  899.     break ; 
  900.   case 15 : 
  901.     printesc ( 373 ) ; 
  902.     break ; 
  903.   case 91 : 
  904.     printesc ( 374 ) ; 
  905.     break ; 
  906.   case 66 : 
  907.     printesc ( 364 ) ; 
  908.     break ; 
  909.   case 62 : 
  910.     printesc ( 375 ) ; 
  911.     break ; 
  912.   case 64 : 
  913.     printesc ( 32 ) ; 
  914.     break ; 
  915.   case 101 : 
  916.     printesc ( 376 ) ; 
  917.     break ; 
  918.   case 32 : 
  919.     printesc ( 379 ) ; 
  920.     break ; 
  921.   case 36 : 
  922.     printesc ( 380 ) ; 
  923.     break ; 
  924.   case 39 : 
  925.     printesc ( 381 ) ; 
  926.     break ; 
  927.   case 37 : 
  928.     printesc ( 198 ) ; 
  929.     break ; 
  930.   case 44 : 
  931.     printesc ( 47 ) ; 
  932.     break ; 
  933.   case 18 : 
  934.     printesc ( 219 ) ; 
  935.     break ; 
  936.   case 46 : 
  937.     printesc ( 382 ) ; 
  938.     break ; 
  939.   case 17 : 
  940.     printesc ( 383 ) ; 
  941.     break ; 
  942.   case 54 : 
  943.     printesc ( 384 ) ; 
  944.     break ; 
  945.   case 90 : 
  946.     printesc ( 385 ) ; 
  947.     break ; 
  948.   case 34 : 
  949.     printesc ( 386 ) ; 
  950.     break ; 
  951.   case 102 : 
  952.     printesc ( 387 ) ; 
  953.     break ; 
  954.   case 55 : 
  955.     printesc ( 203 ) ; 
  956.     break ; 
  957.   case 63 : 
  958.     printesc ( 388 ) ; 
  959.     break ; 
  960.   case 65 : 
  961.     printesc ( 391 ) ; 
  962.     break ; 
  963.   case 95 : 
  964.     printesc ( 392 ) ; 
  965.     break ; 
  966.   case 0 : 
  967.     printesc ( 393 ) ; 
  968.     break ; 
  969.   case 97 : 
  970.     printesc ( 394 ) ; 
  971.     break ; 
  972.   case 79 : 
  973.     printesc ( 390 ) ; 
  974.     break ; 
  975.   case 83 : 
  976.     printesc ( 273 ) ; 
  977.     break ; 
  978.   case 108 : 
  979.     printesc ( 395 ) ; 
  980.     break ; 
  981.   case 70 : 
  982.     printesc ( 272 ) ; 
  983.     break ; 
  984.   case 38 : 
  985.     printesc ( 220 ) ; 
  986.     break ; 
  987.   case 33 : 
  988.     printesc ( 396 ) ; 
  989.     break ; 
  990.   case 56 : 
  991.     printesc ( 397 ) ; 
  992.     break ; 
  993.   case 35 : 
  994.     printesc ( 398 ) ; 
  995.     break ; 
  996.   case 13 : 
  997.     printesc ( 455 ) ; 
  998.     break ; 
  999.   case 103 : 
  1000.     if ( chrcode == 0 ) 
  1001.     printesc ( 487 ) ; 
  1002.     else printesc ( 488 ) ; 
  1003.     break ; 
  1004.   case 109 : 
  1005.     switch ( chrcode ) 
  1006.     {case 1 : 
  1007.       printesc ( 490 ) ; 
  1008.       break ; 
  1009.     case 2 : 
  1010.       printesc ( 491 ) ; 
  1011.       break ; 
  1012.     case 3 : 
  1013.       printesc ( 492 ) ; 
  1014.       break ; 
  1015.     case 4 : 
  1016.       printesc ( 493 ) ; 
  1017.       break ; 
  1018.       default: 
  1019.       printesc ( 489 ) ; 
  1020.       break ; 
  1021.     } 
  1022.     break ; 
  1023.   case 88 : 
  1024.     if ( chrcode == 0 ) 
  1025.     printesc ( 336 ) ; 
  1026.     else if ( chrcode == 1 ) 
  1027.     printesc ( 359 ) ; 
  1028.     else if ( chrcode == 2 ) 
  1029.     printesc ( 260 ) ; 
  1030.     else printesc ( 261 ) ; 
  1031.     break ; 
  1032.   case 78 : 
  1033.     if ( chrcode == 1 ) 
  1034.     printesc ( 527 ) ; 
  1035.     else printesc ( 526 ) ; 
  1036.     break ; 
  1037.   case 81 : 
  1038.     if ( chrcode == 0 ) 
  1039.     printesc ( 528 ) ; 
  1040.     else printesc ( 529 ) ; 
  1041.     break ; 
  1042.   case 82 : 
  1043.     if ( chrcode == 1 ) 
  1044.     printesc ( 530 ) ; 
  1045.     else if ( chrcode == 3 ) 
  1046.     printesc ( 531 ) ; 
  1047.     else printesc ( 532 ) ; 
  1048.     break ; 
  1049.   case 69 : 
  1050.     if ( chrcode == 0 ) 
  1051.     printesc ( 533 ) ; 
  1052.     else if ( chrcode == 1 ) 
  1053.     printesc ( 534 ) ; 
  1054.     else printesc ( 535 ) ; 
  1055.     break ; 
  1056.   case 107 : 
  1057.     switch ( chrcode ) 
  1058.     {case 0 : 
  1059.       printesc ( 592 ) ; 
  1060.       break ; 
  1061.     case 1 : 
  1062.       printesc ( 593 ) ; 
  1063.       break ; 
  1064.     case 2 : 
  1065.       printesc ( 594 ) ; 
  1066.       break ; 
  1067.     case 3 : 
  1068.       printesc ( 595 ) ; 
  1069.       break ; 
  1070.     case 4 : 
  1071.       printesc ( 596 ) ; 
  1072.       break ; 
  1073.       default: 
  1074.       printesc ( 597 ) ; 
  1075.       break ; 
  1076.     } 
  1077.     break ; 
  1078.   case 104 : 
  1079.     switch ( chrcode ) 
  1080.     {case 1 : 
  1081.       printesc ( 614 ) ; 
  1082.       break ; 
  1083.     case 2 : 
  1084.       printesc ( 615 ) ; 
  1085.       break ; 
  1086.     case 3 : 
  1087.       printesc ( 616 ) ; 
  1088.       break ; 
  1089.     case 4 : 
  1090.       printesc ( 617 ) ; 
  1091.       break ; 
  1092.     case 5 : 
  1093.       printesc ( 618 ) ; 
  1094.       break ; 
  1095.     case 6 : 
  1096.       printesc ( 619 ) ; 
  1097.       break ; 
  1098.     case 7 : 
  1099.       printesc ( 620 ) ; 
  1100.       break ; 
  1101.     case 8 : 
  1102.       printesc ( 621 ) ; 
  1103.       break ; 
  1104.     case 9 : 
  1105.       printesc ( 622 ) ; 
  1106.       break ; 
  1107.     case 10 : 
  1108.       printesc ( 623 ) ; 
  1109.       break ; 
  1110.     case 11 : 
  1111.       printesc ( 624 ) ; 
  1112.       break ; 
  1113.     case 12 : 
  1114.       printesc ( 625 ) ; 
  1115.       break ; 
  1116.     case 13 : 
  1117.       printesc ( 626 ) ; 
  1118.       break ; 
  1119.     case 14 : 
  1120.       printesc ( 627 ) ; 
  1121.       break ; 
  1122.     case 15 : 
  1123.       printesc ( 628 ) ; 
  1124.       break ; 
  1125.     case 16 : 
  1126.       printesc ( 629 ) ; 
  1127.       break ; 
  1128.       default: 
  1129.       printesc ( 613 ) ; 
  1130.       break ; 
  1131.     } 
  1132.     break ; 
  1133.   case 105 : 
  1134.     if ( chrcode == 2 ) 
  1135.     printesc ( 630 ) ; 
  1136.     else if ( chrcode == 4 ) 
  1137.     printesc ( 631 ) ; 
  1138.     else printesc ( 632 ) ; 
  1139.     break ; 
  1140.   case 4 : 
  1141.     if ( chrcode == 128 ) 
  1142.     printesc ( 751 ) ; 
  1143.     else {
  1144.     
  1145.       print ( 755 ) ; 
  1146.       printASCII ( chrcode ) ; 
  1147.     } 
  1148.     break ; 
  1149.   case 5 : 
  1150.     if ( chrcode == 129 ) 
  1151.     printesc ( 752 ) ; 
  1152.     else printesc ( 753 ) ; 
  1153.     break ; 
  1154.   case 80 : 
  1155.     switch ( chrcode ) 
  1156.     {case 0 : 
  1157.       printesc ( 818 ) ; 
  1158.       break ; 
  1159.     case 1 : 
  1160.       printesc ( 819 ) ; 
  1161.       break ; 
  1162.     case 2 : 
  1163.       printesc ( 820 ) ; 
  1164.       break ; 
  1165.     case 3 : 
  1166.       printesc ( 821 ) ; 
  1167.       break ; 
  1168.     case 4 : 
  1169.       printesc ( 822 ) ; 
  1170.       break ; 
  1171.     case 5 : 
  1172.       printesc ( 823 ) ; 
  1173.       break ; 
  1174.     case 6 : 
  1175.       printesc ( 824 ) ; 
  1176.       break ; 
  1177.       default: 
  1178.       printesc ( 825 ) ; 
  1179.       break ; 
  1180.     } 
  1181.     break ; 
  1182.   case 14 : 
  1183.     if ( chrcode == 1 ) 
  1184.     printesc ( 874 ) ; 
  1185.     else printesc ( 873 ) ; 
  1186.     break ; 
  1187.   case 26 : 
  1188.     switch ( chrcode ) 
  1189.     {case 4 : 
  1190.       printesc ( 875 ) ; 
  1191.       break ; 
  1192.     case 0 : 
  1193.       printesc ( 876 ) ; 
  1194.       break ; 
  1195.     case 1 : 
  1196.       printesc ( 877 ) ; 
  1197.       break ; 
  1198.     case 2 : 
  1199.       printesc ( 878 ) ; 
  1200.       break ; 
  1201.       default: 
  1202.       printesc ( 879 ) ; 
  1203.       break ; 
  1204.     } 
  1205.     break ; 
  1206.   case 27 : 
  1207.     switch ( chrcode ) 
  1208.     {case 4 : 
  1209.       printesc ( 880 ) ; 
  1210.       break ; 
  1211.     case 0 : 
  1212.       printesc ( 881 ) ; 
  1213.       break ; 
  1214.     case 1 : 
  1215.       printesc ( 882 ) ; 
  1216.       break ; 
  1217.     case 2 : 
  1218.       printesc ( 883 ) ; 
  1219.       break ; 
  1220.       default: 
  1221.       printesc ( 884 ) ; 
  1222.       break ; 
  1223.     } 
  1224.     break ; 
  1225.   case 28 : 
  1226.     printesc ( 204 ) ; 
  1227.     break ; 
  1228.   case 29 : 
  1229.     printesc ( 208 ) ; 
  1230.     break ; 
  1231.   case 30 : 
  1232.     printesc ( 210 ) ; 
  1233.     break ; 
  1234.   case 21 : 
  1235.     if ( chrcode == 1 ) 
  1236.     printesc ( 902 ) ; 
  1237.     else printesc ( 903 ) ; 
  1238.     break ; 
  1239.   case 22 : 
  1240.     if ( chrcode == 1 ) 
  1241.     printesc ( 904 ) ; 
  1242.     else printesc ( 905 ) ; 
  1243.     break ; 
  1244.   case 20 : 
  1245.     switch ( chrcode ) 
  1246.     {case 0 : 
  1247.       printesc ( 274 ) ; 
  1248.       break ; 
  1249.     case 1 : 
  1250.       printesc ( 906 ) ; 
  1251.       break ; 
  1252.     case 2 : 
  1253.       printesc ( 907 ) ; 
  1254.       break ; 
  1255.     case 3 : 
  1256.       printesc ( 813 ) ; 
  1257.       break ; 
  1258.     case 4 : 
  1259.       printesc ( 908 ) ; 
  1260.       break ; 
  1261.     case 5 : 
  1262.       printesc ( 815 ) ; 
  1263.       break ; 
  1264.       default: 
  1265.       printesc ( 909 ) ; 
  1266.       break ; 
  1267.     } 
  1268.     break ; 
  1269.   case 31 : 
  1270.     if ( chrcode == 100 ) 
  1271.     printesc ( 911 ) ; 
  1272.     else if ( chrcode == 101 ) 
  1273.     printesc ( 912 ) ; 
  1274.     else if ( chrcode == 102 ) 
  1275.     printesc ( 913 ) ; 
  1276.     else printesc ( 910 ) ; 
  1277.     break ; 
  1278.   case 43 : 
  1279.     if ( chrcode == 0 ) 
  1280.     printesc ( 929 ) ; 
  1281.     else printesc ( 928 ) ; 
  1282.     break ; 
  1283.   case 25 : 
  1284.     if ( chrcode == 10 ) 
  1285.     printesc ( 940 ) ; 
  1286.     else if ( chrcode == 11 ) 
  1287.     printesc ( 939 ) ; 
  1288.     else printesc ( 938 ) ; 
  1289.     break ; 
  1290.   case 23 : 
  1291.     if ( chrcode == 1 ) 
  1292.     printesc ( 942 ) ; 
  1293.     else printesc ( 941 ) ; 
  1294.     break ; 
  1295.   case 24 : 
  1296.     if ( chrcode == 1 ) 
  1297.     printesc ( 944 ) ; 
  1298.     else printesc ( 943 ) ; 
  1299.     break ; 
  1300.   case 47 : 
  1301.     if ( chrcode == 1 ) 
  1302.     printesc ( 45 ) ; 
  1303.     else printesc ( 217 ) ; 
  1304.     break ; 
  1305.   case 48 : 
  1306.     if ( chrcode == 1 ) 
  1307.     printesc ( 976 ) ; 
  1308.     else printesc ( 975 ) ; 
  1309.     break ; 
  1310.   case 50 : 
  1311.     switch ( chrcode ) 
  1312.     {case 16 : 
  1313.       printesc ( 719 ) ; 
  1314.       break ; 
  1315.     case 17 : 
  1316.       printesc ( 720 ) ; 
  1317.       break ; 
  1318.     case 18 : 
  1319.       printesc ( 721 ) ; 
  1320.       break ; 
  1321.     case 19 : 
  1322.       printesc ( 722 ) ; 
  1323.       break ; 
  1324.     case 20 : 
  1325.       printesc ( 723 ) ; 
  1326.       break ; 
  1327.     case 21 : 
  1328.       printesc ( 724 ) ; 
  1329.       break ; 
  1330.     case 22 : 
  1331.       printesc ( 725 ) ; 
  1332.       break ; 
  1333.     case 23 : 
  1334.       printesc ( 726 ) ; 
  1335.       break ; 
  1336.     case 26 : 
  1337.       printesc ( 728 ) ; 
  1338.       break ; 
  1339.       default: 
  1340.       printesc ( 727 ) ; 
  1341.       break ; 
  1342.     } 
  1343.     break ; 
  1344.   case 51 : 
  1345.     if ( chrcode == 1 ) 
  1346.     printesc ( 731 ) ; 
  1347.     else if ( chrcode == 2 ) 
  1348.     printesc ( 732 ) ; 
  1349.     else printesc ( 977 ) ; 
  1350.     break ; 
  1351.   case 53 : 
  1352.     printstyle ( chrcode ) ; 
  1353.     break ; 
  1354.   case 52 : 
  1355.     switch ( chrcode ) 
  1356.     {case 1 : 
  1357.       printesc ( 996 ) ; 
  1358.       break ; 
  1359.     case 2 : 
  1360.       printesc ( 997 ) ; 
  1361.       break ; 
  1362.     case 3 : 
  1363.       printesc ( 998 ) ; 
  1364.       break ; 
  1365.     case 4 : 
  1366.       printesc ( 999 ) ; 
  1367.       break ; 
  1368.     case 5 : 
  1369.       printesc ( 1000 ) ; 
  1370.       break ; 
  1371.       default: 
  1372.       printesc ( 995 ) ; 
  1373.       break ; 
  1374.     } 
  1375.     break ; 
  1376.   case 49 : 
  1377.     if ( chrcode == 30 ) 
  1378.     printesc ( 729 ) ; 
  1379.     else printesc ( 730 ) ; 
  1380.     break ; 
  1381.   case 92 : 
  1382.     if ( chrcode == 1 ) 
  1383.     printesc ( 1019 ) ; 
  1384.     else if ( chrcode == 2 ) 
  1385.     printesc ( 1020 ) ; 
  1386.     else printesc ( 1021 ) ; 
  1387.     break ; 
  1388.   case 96 : 
  1389.     if ( chrcode == 0 ) 
  1390.     printesc ( 1022 ) ; 
  1391.     else if ( chrcode == 1 ) 
  1392.     printesc ( 1023 ) ; 
  1393.     else if ( chrcode == 2 ) 
  1394.     printesc ( 1024 ) ; 
  1395.     else printesc ( 1025 ) ; 
  1396.     break ; 
  1397.   case 93 : 
  1398.     if ( chrcode != 0 ) 
  1399.     printesc ( 1040 ) ; 
  1400.     else printesc ( 1039 ) ; 
  1401.     break ; 
  1402.   case 94 : 
  1403.     switch ( chrcode ) 
  1404.     {case 0 : 
  1405.       printesc ( 1041 ) ; 
  1406.       break ; 
  1407.     case 1 : 
  1408.       printesc ( 1042 ) ; 
  1409.       break ; 
  1410.     case 2 : 
  1411.       printesc ( 1043 ) ; 
  1412.       break ; 
  1413.     case 3 : 
  1414.       printesc ( 1044 ) ; 
  1415.       break ; 
  1416.     case 4 : 
  1417.       printesc ( 1045 ) ; 
  1418.       break ; 
  1419.     case 5 : 
  1420.       printesc ( 1046 ) ; 
  1421.       break ; 
  1422.       default: 
  1423.       printesc ( 1047 ) ; 
  1424.       break ; 
  1425.     } 
  1426.     break ; 
  1427.   case 67 : 
  1428.     {
  1429.       printesc ( 372 ) ; 
  1430.       printhex ( chrcode ) ; 
  1431.     } 
  1432.     break ; 
  1433.   case 68 : 
  1434.     {
  1435.       printesc ( 383 ) ; 
  1436.       printhex ( chrcode ) ; 
  1437.     } 
  1438.     break ; 
  1439.   case 84 : 
  1440.     if ( chrcode == 4627 ) 
  1441.     printesc ( 280 ) ; 
  1442.     else if ( chrcode == 5139 ) 
  1443.     printesc ( 284 ) ; 
  1444.     else if ( chrcode == 4755 ) 
  1445.     printesc ( 281 ) ; 
  1446.     else if ( chrcode == 4883 ) 
  1447.     printesc ( 282 ) ; 
  1448.     else if ( chrcode == 5011 ) 
  1449.     printesc ( 283 ) ; 
  1450.     else printesc ( 337 ) ; 
  1451.     break ; 
  1452.   case 85 : 
  1453.     printsize ( chrcode - 4579 ) ; 
  1454.     break ; 
  1455.   case 98 : 
  1456.     if ( chrcode == 1 ) 
  1457.     printesc ( 803 ) ; 
  1458.     else printesc ( 793 ) ; 
  1459.     break ; 
  1460.   case 77 : 
  1461.     if ( chrcode == 0 ) 
  1462.     printesc ( 1063 ) ; 
  1463.     else printesc ( 1064 ) ; 
  1464.     break ; 
  1465.   case 86 : 
  1466.     {
  1467.       print ( 1072 ) ; 
  1468.       print ( fontname [ chrcode ] ) ; 
  1469.       if ( fontsize [ chrcode ] != fontdsize [ chrcode ] ) 
  1470.       {
  1471.     print ( 598 ) ; 
  1472.     printscaled ( fontsize [ chrcode ] ) ; 
  1473.     print ( 262 ) ; 
  1474.       } 
  1475.     } 
  1476.     break ; 
  1477.   case 99 : 
  1478.     switch ( chrcode ) 
  1479.     {case 0 : 
  1480.       printesc ( 143 ) ; 
  1481.       break ; 
  1482.     case 1 : 
  1483.       printesc ( 144 ) ; 
  1484.       break ; 
  1485.     case 2 : 
  1486.       printesc ( 145 ) ; 
  1487.       break ; 
  1488.       default: 
  1489.       printesc ( 1073 ) ; 
  1490.       break ; 
  1491.     } 
  1492.     break ; 
  1493.   case 60 : 
  1494.     if ( chrcode == 0 ) 
  1495.     printesc ( 1075 ) ; 
  1496.     else printesc ( 1074 ) ; 
  1497.     break ; 
  1498.   case 58 : 
  1499.     if ( chrcode == 0 ) 
  1500.     printesc ( 1076 ) ; 
  1501.     else printesc ( 1077 ) ; 
  1502.     break ; 
  1503.   case 57 : 
  1504.     if ( chrcode == 4755 ) 
  1505.     printesc ( 1083 ) ; 
  1506.     else printesc ( 1084 ) ; 
  1507.     break ; 
  1508.   case 19 : 
  1509.     switch ( chrcode ) 
  1510.     {case 1 : 
  1511.       printesc ( 1086 ) ; 
  1512.       break ; 
  1513.     case 2 : 
  1514.       printesc ( 1087 ) ; 
  1515.       break ; 
  1516.     case 3 : 
  1517.       printesc ( 1088 ) ; 
  1518.       break ; 
  1519.       default: 
  1520.       printesc ( 1085 ) ; 
  1521.       break ; 
  1522.     } 
  1523.     break ; 
  1524.   case 100 : 
  1525.     print ( 1095 ) ; 
  1526.     break ; 
  1527.   case 110 : 
  1528.     print ( 1096 ) ; 
  1529.     break ; 
  1530.   case 111 : 
  1531.     printesc ( 1097 ) ; 
  1532.     break ; 
  1533.   case 112 : 
  1534.     printesc ( 1098 ) ; 
  1535.     break ; 
  1536.   case 113 : 
  1537.     {
  1538.       printesc ( 1019 ) ; 
  1539.       printesc ( 1098 ) ; 
  1540.     } 
  1541.     break ; 
  1542.   case 114 : 
  1543.     printesc ( 1099 ) ; 
  1544.     break ; 
  1545.   case 59 : 
  1546.     switch ( chrcode ) 
  1547.     {case 0 : 
  1548.       printesc ( 1129 ) ; 
  1549.       break ; 
  1550.     case 1 : 
  1551.       printesc ( 452 ) ; 
  1552.       break ; 
  1553.     case 2 : 
  1554.       printesc ( 1130 ) ; 
  1555.       break ; 
  1556.     case 3 : 
  1557.       printesc ( 1131 ) ; 
  1558.       break ; 
  1559.     case 4 : 
  1560.       printesc ( 1132 ) ; 
  1561.       break ; 
  1562.       default: 
  1563.       print ( 1133 ) ; 
  1564.       break ; 
  1565.     } 
  1566.     break ; 
  1567.     default: 
  1568.     print ( 425 ) ; 
  1569.     break ; 
  1570.   } 
  1571. } 
  1572. #ifdef STAT
  1573. zshoweqtb ( n ) 
  1574. halfword n ; 
  1575. {showeqtb_regmem 
  1576.   if ( n < 1 ) 
  1577.   printchar ( 63 ) ; 
  1578.   else if ( n < 3526 ) 
  1579.   {
  1580.     sprintcs ( n ) ; 
  1581.     printchar ( 61 ) ; 
  1582.     printcmdchr ( eqtb [ n ] .hh.b0 , eqtb [ n ] .hh .v.RH ) ; 
  1583.     if ( eqtb [ n ] .hh.b0 >= 110 ) 
  1584.     {
  1585.       printchar ( 58 ) ; 
  1586.       showtokenlist ( mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  1587.     } 
  1588.   } 
  1589.   else if ( n < 4056 ) 
  1590.   if ( n < 3544 ) 
  1591.   {
  1592.     printskipparam ( n - 3526 ) ; 
  1593.     printchar ( 61 ) ; 
  1594.     if ( n < 3541 ) 
  1595.     printspec ( eqtb [ n ] .hh .v.RH , 262 ) ; 
  1596.     else printspec ( eqtb [ n ] .hh .v.RH , 205 ) ; 
  1597.   } 
  1598.   else if ( n < 3800 ) 
  1599.   {
  1600.     printesc ( 260 ) ; 
  1601.     printint ( n - 3544 ) ; 
  1602.     printchar ( 61 ) ; 
  1603.     printspec ( eqtb [ n ] .hh .v.RH , 262 ) ; 
  1604.   } 
  1605.   else {
  1606.       
  1607.     printesc ( 261 ) ; 
  1608.     printint ( n - 3800 ) ; 
  1609.     printchar ( 61 ) ; 
  1610.     printspec ( eqtb [ n ] .hh .v.RH , 205 ) ; 
  1611.   } 
  1612.   else if ( n < 5267 ) 
  1613.   if ( n == 4056 ) 
  1614.   {
  1615.     printesc ( 273 ) ; 
  1616.     printchar ( 61 ) ; 
  1617.     if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  1618.     printchar ( 48 ) ; 
  1619.     else printint ( mem [ eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ) ; 
  1620.   } 
  1621.   else if ( n < 4066 ) 
  1622.   {
  1623.     printcmdchr ( 71 , n ) ; 
  1624.     printchar ( 61 ) ; 
  1625.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  1626.     showtokenlist ( mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  1627.   } 
  1628.   else if ( n < 4322 ) 
  1629.   {
  1630.     printesc ( 272 ) ; 
  1631.     printint ( n - 4066 ) ; 
  1632.     printchar ( 61 ) ; 
  1633.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  1634.     showtokenlist ( mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  1635.   } 
  1636.   else if ( n < 4578 ) 
  1637.   {
  1638.     printesc ( 274 ) ; 
  1639.     printint ( n - 4322 ) ; 
  1640.     printchar ( 61 ) ; 
  1641.     if ( eqtb [ n ] .hh .v.RH == 0 ) 
  1642.     print ( 275 ) ; 
  1643.     else {
  1644.     
  1645.       depththreshold = 0 ; 
  1646.       breadthmax = 1 ; 
  1647.       shownodelist ( eqtb [ n ] .hh .v.RH ) ; 
  1648.     } 
  1649.   } 
  1650.   else if ( n < 4627 ) 
  1651.   {
  1652.     if ( n == 4578 ) 
  1653.     print ( 276 ) ; 
  1654.     else if ( n < 4595 ) 
  1655.     {
  1656.       printesc ( 277 ) ; 
  1657.       printint ( n - 4579 ) ; 
  1658.     } 
  1659.     else if ( n < 4611 ) 
  1660.     {
  1661.       printesc ( 278 ) ; 
  1662.       printint ( n - 4595 ) ; 
  1663.     } 
  1664.     else {
  1665.     
  1666.       printesc ( 279 ) ; 
  1667.       printint ( n - 4611 ) ; 
  1668.     } 
  1669.     printchar ( 61 ) ; 
  1670.     printesc ( hash [ 3268 + eqtb [ n ] .hh .v.RH ] .v.RH ) ; 
  1671.   } 
  1672.   else if ( n < 5139 ) 
  1673.   {
  1674.     if ( n < 4755 ) 
  1675.     {
  1676.       printesc ( 280 ) ; 
  1677.       printint ( n - 4627 ) ; 
  1678.     } 
  1679.     else if ( n < 4883 ) 
  1680.     {
  1681.       printesc ( 281 ) ; 
  1682.       printint ( n - 4755 ) ; 
  1683.     } 
  1684.     else if ( n < 5011 ) 
  1685.     {
  1686.       printesc ( 282 ) ; 
  1687.       printint ( n - 4883 ) ; 
  1688.     } 
  1689.     else {
  1690.     
  1691.       printesc ( 283 ) ; 
  1692.       printint ( n - 5011 ) ; 
  1693.     } 
  1694.     printchar ( 61 ) ; 
  1695.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  1696.   } 
  1697.   else {
  1698.       
  1699.     printesc ( 284 ) ; 
  1700.     printint ( n - 5139 ) ; 
  1701.     printchar ( 61 ) ; 
  1702.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  1703.   } 
  1704.   else if ( n < 5701 ) 
  1705.   {
  1706.     if ( n < 5317 ) 
  1707.     printparam ( n - 5267 ) ; 
  1708.     else if ( n < 5573 ) 
  1709.     {
  1710.       printesc ( 336 ) ; 
  1711.       printint ( n - 5317 ) ; 
  1712.     } 
  1713.     else {
  1714.     
  1715.       printesc ( 337 ) ; 
  1716.       printint ( n - 5573 ) ; 
  1717.     } 
  1718.     printchar ( 61 ) ; 
  1719.     printint ( eqtb [ n ] .cint ) ; 
  1720.   } 
  1721.   else if ( n <= 5976 ) 
  1722.   {
  1723.     if ( n < 5721 ) 
  1724.     printlengthparam ( n - 5701 ) ; 
  1725.     else {
  1726.     
  1727.       printesc ( 359 ) ; 
  1728.       printint ( n - 5721 ) ; 
  1729.     } 
  1730.     printchar ( 61 ) ; 
  1731.     printscaled ( eqtb [ n ] .cint ) ; 
  1732.     print ( 262 ) ; 
  1733.   } 
  1734.   else printchar ( 63 ) ; 
  1735. } 
  1736. #endif /* STAT */
  1737. halfword zidlookup ( j , l ) 
  1738. integer j , l ; 
  1739. {/* 40 */ register halfword Result; idlookup_regmem 
  1740.   integer h  ; 
  1741.   halfword p  ; 
  1742.   halfword k  ; 
  1743.   h = buffer [ j ] ; 
  1744.   {register integer for_end; k = j + 1 ; for_end = j + l - 1 ; if ( k <= 
  1745.   for_end) do 
  1746.     {
  1747.       h = h + h + buffer [ k ] ; 
  1748.       while ( h >= 2551 ) h = h - 2551 ; 
  1749.     } 
  1750.   while ( k++ < for_end ) ; } 
  1751.   p = h + 258 ; 
  1752.   while ( true ) {
  1753.       
  1754.     if ( hash [ p ] .v.RH > 0 ) 
  1755.     if ( ( strstart [ hash [ p ] .v.RH + 1 ] - strstart [ hash [ p ] .v.RH ] ) 
  1756.     == l ) 
  1757.     if ( streqbuf ( hash [ p ] .v.RH , j ) ) 
  1758.     goto lab40 ; 
  1759.     if ( hash [ p ] .v.LH == 0 ) 
  1760.     {
  1761.       if ( nonewcontrolsequence ) 
  1762.       p = 3525 ; 
  1763.       else {
  1764.       
  1765.     if ( hash [ p ] .v.RH > 0 ) 
  1766.     {
  1767.       do {
  1768.           if ( ( hashused == 258 ) ) 
  1769.         overflow ( 362 , 3000 ) ; 
  1770.         decr ( hashused ) ; 
  1771.       } while ( ! ( hash [ hashused ] .v.RH == 0 ) ) ; 
  1772.       hash [ p ] .v.LH = hashused ; 
  1773.       p = hashused ; 
  1774.     } 
  1775.     {
  1776.       if ( poolptr + l > poolsize ) 
  1777.       overflow ( 128 , poolsize - initpoolptr ) ; 
  1778.     } 
  1779.     {register integer for_end; k = j ; for_end = j + l - 1 ; if ( k <= 
  1780.     for_end) do 
  1781.       {
  1782.         strpool [ poolptr ] = buffer [ k ] ; 
  1783.         incr ( poolptr ) ; 
  1784.       } 
  1785.     while ( k++ < for_end ) ; } 
  1786.     hash [ p ] .v.RH = makestring () ; 
  1787.     ;
  1788. #ifdef STAT
  1789.     incr ( cscount ) ; 
  1790. #endif /* STAT */
  1791.       } 
  1792.       goto lab40 ; 
  1793.     } 
  1794.     p = hash [ p ] .v.LH ; 
  1795.   } 
  1796.   lab40: Result = p ; 
  1797.   return(Result) ; 
  1798. } 
  1799. znewsavelevel ( c ) 
  1800. groupcode c ; 
  1801. {newsavelevel_regmem 
  1802.   if ( saveptr > maxsavestack ) 
  1803.   {
  1804.     maxsavestack = saveptr ; 
  1805.     if ( maxsavestack > savesize - 6 ) 
  1806.     overflow ( 399 , savesize ) ; 
  1807.   } 
  1808.   savestack [ saveptr ] .hh.b0 = 3 ; 
  1809.   savestack [ saveptr ] .hh.b1 = curgroup ; 
  1810.   savestack [ saveptr ] .hh .v.RH = curboundary ; 
  1811.   if ( curlevel == 255 ) 
  1812.   overflow ( 400 , 255 ) ; 
  1813.   curboundary = saveptr ; 
  1814.   incr ( curlevel ) ; 
  1815.   incr ( saveptr ) ; 
  1816.   curgroup = c ; 
  1817. } 
  1818. zeqdestroy ( w ) 
  1819. memoryword w ; 
  1820. {eqdestroy_regmem 
  1821.   halfword q  ; 
  1822.   switch ( w .hh.b0 ) 
  1823.   {case 110 : 
  1824.   case 111 : 
  1825.   case 112 : 
  1826.   case 113 : 
  1827.     deletetokenref ( w .hh .v.RH ) ; 
  1828.     break ; 
  1829.   case 116 : 
  1830.     deleteglueref ( w .hh .v.RH ) ; 
  1831.     break ; 
  1832.   case 117 : 
  1833.     {
  1834.       q = w .hh .v.RH ; 
  1835.       if ( q != 0 ) 
  1836.       freenode ( q , mem [ q ] .hh .v.LH + mem [ q ] .hh .v.LH + 1 ) ; 
  1837.     } 
  1838.     break ; 
  1839.   case 118 : 
  1840.     flushnodelist ( w .hh .v.RH ) ; 
  1841.     break ; 
  1842.     default: 
  1843.     ; 
  1844.     break ; 
  1845.   } 
  1846. } 
  1847. zeqsave ( p , l ) 
  1848. halfword p ; 
  1849. quarterword l ; 
  1850. {eqsave_regmem 
  1851.   if ( saveptr > maxsavestack ) 
  1852.   {
  1853.     maxsavestack = saveptr ; 
  1854.     if ( maxsavestack > savesize - 6 ) 
  1855.     overflow ( 399 , savesize ) ; 
  1856.   } 
  1857.   if ( l == 0 ) 
  1858.   savestack [ saveptr ] .hh.b0 = 1 ; 
  1859.   else {
  1860.       
  1861.     savestack [ saveptr ] = eqtb [ p ] ; 
  1862.     incr ( saveptr ) ; 
  1863.     savestack [ saveptr ] .hh.b0 = 0 ; 
  1864.   } 
  1865.   savestack [ saveptr ] .hh.b1 = l ; 
  1866.   savestack [ saveptr ] .hh .v.RH = p ; 
  1867.   incr ( saveptr ) ; 
  1868. } 
  1869. zeqdefine ( p , t , e ) 
  1870. halfword p ; 
  1871. quarterword t ; 
  1872. halfword e ; 
  1873. {eqdefine_regmem 
  1874.   if ( eqtb [ p ] .hh.b1 == curlevel ) 
  1875.   eqdestroy ( eqtb [ p ] ) ; 
  1876.   else if ( curlevel > 1 ) 
  1877.   eqsave ( p , eqtb [ p ] .hh.b1 ) ; 
  1878.   eqtb [ p ] .hh.b1 = curlevel ; 
  1879.   eqtb [ p ] .hh.b0 = t ; 
  1880.   eqtb [ p ] .hh .v.RH = e ; 
  1881. } 
  1882. zeqworddefine ( p , w ) 
  1883. halfword p ; 
  1884. integer w ; 
  1885. {eqworddefine_regmem 
  1886.   if ( xeqlevel [ p ] != curlevel ) 
  1887.   {
  1888.     eqsave ( p , xeqlevel [ p ] ) ; 
  1889.     xeqlevel [ p ] = curlevel ; 
  1890.   } 
  1891.   eqtb [ p ] .cint = w ; 
  1892. } 
  1893. zgeqdefine ( p , t , e ) 
  1894. halfword p ; 
  1895. quarterword t ; 
  1896. halfword e ; 
  1897. {geqdefine_regmem 
  1898.   eqdestroy ( eqtb [ p ] ) ; 
  1899.   eqtb [ p ] .hh.b1 = 1 ; 
  1900.   eqtb [ p ] .hh.b0 = t ; 
  1901.   eqtb [ p ] .hh .v.RH = e ; 
  1902. } 
  1903. zgeqworddefine ( p , w ) 
  1904. halfword p ; 
  1905. integer w ; 
  1906. {geqworddefine_regmem 
  1907.   eqtb [ p ] .cint = w ; 
  1908.   xeqlevel [ p ] = 1 ; 
  1909. } 
  1910. zsaveforafter ( t ) 
  1911. halfword t ; 
  1912. {saveforafter_regmem 
  1913.   if ( saveptr > maxsavestack ) 
  1914.   {
  1915.     maxsavestack = saveptr ; 
  1916.     if ( maxsavestack > savesize - 6 ) 
  1917.     overflow ( 399 , savesize ) ; 
  1918.   } 
  1919.   savestack [ saveptr ] .hh.b0 = 2 ; 
  1920.   savestack [ saveptr ] .hh.b1 = 0 ; 
  1921.   savestack [ saveptr ] .hh .v.RH = t ; 
  1922.   incr ( saveptr ) ; 
  1923. } 
  1924. #ifdef STAT
  1925. zrestoretrace ( p , s ) 
  1926. halfword p ; 
  1927. strnumber s ; 
  1928. {restoretrace_regmem 
  1929.   begindiagnostic () ; 
  1930.   printchar ( 123 ) ; 
  1931.   print ( s ) ; 
  1932.   printchar ( 32 ) ; 
  1933.   showeqtb ( p ) ; 
  1934.   printchar ( 125 ) ; 
  1935.   enddiagnostic ( false ) ; 
  1936. } 
  1937. #endif /* STAT */
  1938. unsave () {
  1939.     /* 30 */ unsave_regmem 
  1940.   halfword p  ; 
  1941.   quarterword l  ; 
  1942.   halfword t  ; 
  1943.   if ( curlevel > 1 ) 
  1944.   {
  1945.     decr ( curlevel ) ; 
  1946.     while ( true ) {
  1947.     
  1948.       decr ( saveptr ) ; 
  1949.       if ( savestack [ saveptr ] .hh.b0 == 3 ) 
  1950.       goto lab30 ; 
  1951.       p = savestack [ saveptr ] .hh .v.RH ; 
  1952.       if ( savestack [ saveptr ] .hh.b0 == 2 ) 
  1953.       {
  1954.     t = curtok ; 
  1955.     curtok = p ; 
  1956.     backinput () ; 
  1957.     curtok = t ; 
  1958.       } 
  1959.       else {
  1960.       
  1961.     if ( savestack [ saveptr ] .hh.b0 == 0 ) 
  1962.     {
  1963.       l = savestack [ saveptr ] .hh.b1 ; 
  1964.       decr ( saveptr ) ; 
  1965.     } 
  1966.     else savestack [ saveptr ] = eqtb [ 3525 ] ; 
  1967.     if ( p < 5267 ) 
  1968.     if ( eqtb [ p ] .hh.b1 == 1 ) 
  1969.     {
  1970.       eqdestroy ( savestack [ saveptr ] ) ; 
  1971.     ;
  1972. #ifdef STAT
  1973.       if ( eqtb [ 5304 ] .cint > 0 ) 
  1974.       restoretrace ( p , 402 ) ; 
  1975. #endif /* STAT */
  1976.     } 
  1977.     else {
  1978.         
  1979.       eqdestroy ( eqtb [ p ] ) ; 
  1980.       eqtb [ p ] = savestack [ saveptr ] ; 
  1981.     ;
  1982. #ifdef STAT
  1983.       if ( eqtb [ 5304 ] .cint > 0 ) 
  1984.       restoretrace ( p , 403 ) ; 
  1985. #endif /* STAT */
  1986.     } 
  1987.     else if ( xeqlevel [ p ] != 1 ) 
  1988.     {
  1989.       eqtb [ p ] = savestack [ saveptr ] ; 
  1990.       xeqlevel [ p ] = l ; 
  1991.     ;
  1992. #ifdef STAT
  1993.       if ( eqtb [ 5304 ] .cint > 0 ) 
  1994.       restoretrace ( p , 403 ) ; 
  1995. #endif /* STAT */
  1996.     } 
  1997.     else {
  1998.         
  1999.     ;
  2000. #ifdef STAT
  2001.       if ( eqtb [ 5304 ] .cint > 0 ) 
  2002.       restoretrace ( p , 402 ) ; 
  2003. #endif /* STAT */
  2004.     } 
  2005.       } 
  2006.     } 
  2007.     lab30: curgroup = savestack [ saveptr ] .hh.b1 ; 
  2008.     curboundary = savestack [ saveptr ] .hh .v.RH ; 
  2009.   } 
  2010.   else confusion ( 401 ) ; 
  2011. } 
  2012.